home *** CD-ROM | disk | FTP | other *** search
/ Aminet 45 / Aminet 45 (2001)(GTI - Schatztruhe)[!][Oct 2001].iso / Aminet / util / misc / ReportPlus.lha / reportplus / source / f4.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-08-20  |  21.5 KB  |  640 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <proto/exec.h>
  4. #include <intuition/intuition.h>
  5. #include <intuition/gadgetclass.h>
  6. #include <proto/intuition.h>
  7. #include <libraries/gadtools.h>
  8. #include <proto/gadtools.h>
  9.  
  10. #include <ctype.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include "rp.h"
  14.  
  15. MODULE void bizarre(void);
  16. MODULE void updateautodocgadgets(void);
  17. MODULE void readautodocgadgets(void);
  18. MODULE void starify(ULONG theindex, STRPTR buffer);
  19. MODULE void countfields(void);
  20.  
  21. AGLOBAL UBYTE*               StarBufferPtr[MAXELEMENTS + 1];
  22. AGLOBAL ULONG                StarBufferSize[MAXELEMENTS + 1],
  23.                              returncode,
  24.                              inputs;
  25. AGLOBAL struct AutodocStruct autodoc;
  26.  
  27. MODULE struct Gadget *ST41_Library            = NULL,
  28.                      *ST41_Function           = NULL,
  29.                      *ST41_Desc               = NULL,
  30.                      *IN41_Version            = NULL,
  31.                      *TE41_Label              = NULL,
  32.                      *ST41_VarType[9],
  33.                      *ST41_VarName[9],
  34.                      *ST41_VarReg[9];
  35.  
  36. IMPORT struct NewGadget    Gadget;
  37. IMPORT struct Window*      MainWindowPtr;
  38. IMPORT struct SharedStruct shared;
  39. IMPORT struct Gadget      *BU99_Right,
  40.                           *BU99_TextEditor,
  41.                           *GListPtr,
  42.                           *PrevGadPtr;
  43. IMPORT SBYTE               page;
  44. IMPORT TEXT                aslresult[MEDFIELD + 1],
  45.                            IOBuffer[LONGESTFIELD + 1];
  46.  
  47. AGLOBAL void autodoc1(void)
  48. {   TEXT  temp[MEDFIELD + 1], string[9][MEDFIELD + 1];
  49.     UBYTE i;
  50.  
  51.     verynewwindow
  52.     (   AUTODOCWIDTH, AUTODOCHEIGHT,
  53.         "Report+: Autodocs Entry",
  54.         BUTTONIDCMP | STRINGIDCMP
  55.     );
  56.     OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_NEW,    NOSUB));
  57.     // OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_OPEN,   NOSUB));
  58.     OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_SAVE,   NOSUB));
  59.     OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_SAVEAS, NOSUB));
  60.  
  61.     /* library */
  62.     setgadget(128, 24, 200, 12, "module._type:", PLACETEXT_LEFT);
  63.     ST41_Library = PrevGadPtr = (struct Gadget *) CreateGadget
  64.     (   STRING_KIND,
  65.         PrevGadPtr,
  66.         &Gadget,
  67.         GTST_String, autodoc.library,
  68.         GTST_MaxChars, MEDFIELD,
  69.         GA_TabCycle, TRUE,
  70.         GT_Underscore, '_',
  71.         TAG_DONE
  72.     );
  73.  
  74.     /* version */
  75.     setgadget(544, 24, 64, 12, "Minimum _version:", PLACETEXT_LEFT);
  76.     IN41_Version = PrevGadPtr = (struct Gadget *) CreateGadget
  77.     (   INTEGER_KIND,
  78.         PrevGadPtr,
  79.         &Gadget,
  80.         GTIN_Number, autodoc.version,
  81.         GTST_MaxChars, MEDFIELD,
  82.         GA_TabCycle, TRUE,
  83.         GT_Underscore, '_',
  84.         TAG_DONE
  85.     );
  86.  
  87.     /* function */
  88.     setgadget(128, 38, 200, 12, "Function_Name:", PLACETEXT_LEFT);
  89.     ST41_Function = PrevGadPtr = (struct Gadget *) CreateGadget
  90.     (   STRING_KIND,
  91.         PrevGadPtr,
  92.         &Gadget,
  93.         GTST_String, autodoc.function,
  94.         GTST_MaxChars, MEDFIELD,
  95.         GA_TabCycle, TRUE,
  96.         GT_Underscore, '_',
  97.         TAG_DONE
  98.     );
  99.  
  100.     /* description */
  101.     setgadget(128, 52, 480, 12, "_Description:", PLACETEXT_LEFT);
  102.     ST41_Desc = PrevGadPtr = (struct Gadget *) CreateGadget
  103.     (   STRING_KIND,
  104.     PrevGadPtr,
  105.     &Gadget,
  106.         GTST_String, autodoc.description,
  107.     GTST_MaxChars, VLONGFIELD,
  108.     GA_TabCycle, TRUE,
  109.         GT_Underscore, '_',
  110.     TAG_DONE
  111.     );
  112.  
  113.     /* variable type */
  114.     setgadget(128, 72, 158, 1, "Type", PLACETEXT_BELOW);
  115.     TE41_Label = PrevGadPtr = (struct Gadget *) CreateGadget
  116.     (   TEXT_KIND,
  117.     PrevGadPtr,
  118.     &Gadget,
  119.     TAG_DONE
  120.     );
  121.  
  122.     strcpy(string[0], "_Return code:");
  123.     for (i = 1; i <= 8; i++)
  124.     {   strcpy(string[i], "Argument _");
  125.         stcl_d(temp, i);
  126.         strcat(string[i], temp);
  127.         strcat(string[i], ":");
  128.     }
  129.     for (i = 0; i <= 8; i++)
  130.     {   setgadget(128, 88 + (i * 14), 158, 12, string[i], PLACETEXT_LEFT);
  131.         ST41_VarType[i] = PrevGadPtr = (struct Gadget *) CreateGadget
  132.         (   STRING_KIND,
  133.             PrevGadPtr,
  134.             &Gadget,
  135.             GTST_String, &(autodoc.var[i].type),
  136.             GTST_MaxChars, MEDFIELD,
  137.             GA_TabCycle, TRUE,
  138.             GT_Underscore, '_',
  139.             TAG_DONE
  140.         );
  141.         if (i == 0)
  142.             setgadget(288, 88 + (i * 14), 256, 12, "Name", PLACETEXT_ABOVE);
  143.         else setgadget(288, 88 + (i * 14), 256, 12, NULL, NULL);
  144.         ST41_VarName[i] = PrevGadPtr = (struct Gadget *) CreateGadget
  145.         (   STRING_KIND,
  146.             PrevGadPtr,
  147.             &Gadget,
  148.             GTST_String, &(autodoc.var[i].name),
  149.             GTST_MaxChars, MEDFIELD,
  150.             GA_TabCycle, TRUE,
  151.             TAG_DONE
  152.         );
  153.         if (i == 0)
  154.             setgadget(544, 88 + (i * 14), 64, 12, "Register", PLACETEXT_ABOVE);
  155.         else setgadget(544, 88 + (i * 14), 64, 12, NULL, NULL);
  156.         ST41_VarReg[i] = PrevGadPtr = (struct Gadget *) CreateGadget
  157.         (   STRING_KIND,
  158.             PrevGadPtr,
  159.             &Gadget,
  160.             GTST_String, &(autodoc.var[i].reg),
  161.             GTST_MaxChars, MEDFIELD,
  162.             GA_TabCycle, TRUE,
  163.             TAG_DONE
  164.         );
  165.     }
  166.  
  167.     /* text editor... */
  168.     setgadget(250, 220, 140, 12, "Text ed_itor...", NULL);
  169.     BU99_TextEditor = PrevGadPtr = (struct Gadget *) CreateGadget
  170.     (   BUTTON_KIND,
  171.         PrevGadPtr,
  172.         &Gadget,
  173.         GT_Underscore, '_',
  174.         TAG_DONE
  175.     );
  176.  
  177.     drawgadgets((UWORD) ~0);
  178.     loop();
  179.     readautodocgadgets();
  180.     closewindow();
  181. }
  182.  
  183. AGLOBAL void saveautodoc(ABOOL saveas)
  184. {   ULONG i, j;
  185.     TEXT  temp[MEDFIELD + 1];
  186.     SWORD size;
  187.  
  188.     readautodocgadgets();
  189.    
  190.     strcpy(IOBuffer, "/" "****** ");        //  1:  "/###### "
  191.     strcat(IOBuffer, autodoc.library);      //  1:  "/###### <library>"
  192.     strcat(IOBuffer, "/");                  //  1:  "/###### <library>/"
  193.     strcat(IOBuffer, autodoc.function);     //  1:  "/###### <library>/<function>"
  194.     strcat(IOBuffer, " ");                  //  1:  "/###### <library>/<function> "
  195.  
  196.     size = 67 - strlen(autodoc.library) - strlen(autodoc.function);
  197.     if (size > 0)
  198.     {   for (i = 1; i <= size; i++)           
  199.             strcat(IOBuffer, "*");          //  1:  "/###### <library>/<function> <stars>"
  200.     }
  201.  
  202.     strcat(IOBuffer, "\n*\n*   NAME\n*   ");
  203.                                             //  1:  "/###### <library>/<function> <stars>\n"
  204.                                             //  2:  "#\n"
  205.                                             //  3:  "#   NAME\n"
  206.                                             //  4:  "#   "
  207.     strcat(IOBuffer, autodoc.function);     //  4:  "#   <function>"
  208.     strcat(IOBuffer, " -- ");               //  4:  "#   <function> -- "
  209.     strcat(IOBuffer, autodoc.description);
  210.                                             //  4:  "#   <function> -- <description>"
  211.     if (autodoc.version)
  212.     {   strcat(IOBuffer, " (V");            //  4:  "#   <function> -- <description>[ (V]"
  213.         stcl_d(temp, autodoc.version);
  214.         strcat(IOBuffer, temp);             //  4:  "#   <function> -- <description>[ (V<version>]"
  215.         strcat(IOBuffer, ")");              //  4:  "#   <function> -- <description>[ (V<version>)]
  216.     }
  217.     strcat(IOBuffer, "\n*\n*   SYNOPSIS\n");
  218.                                             //  4:  "#   <function> -- <description>[ (V<version>)]\n"
  219.                                             //  5:  "#\n"
  220.                                             //  6:  "#   SYNOPSIS\n"
  221.  
  222.     // name line
  223.     strcat(IOBuffer, "*   ");               //  7:  "#   "
  224.     if (autodoc.var[0].name[0])
  225.     {   strcat(IOBuffer, autodoc.var[0].name);
  226.                                             //  7:  "#   [<returnname>]"
  227.         strcat(IOBuffer, " = ");            //  7:  "#   [<returnname> = ]"
  228.     }
  229.     strcat(IOBuffer, autodoc.function);     //  7:  "#   [<returnname> = ]<function>"
  230.     strcat(IOBuffer, "(");                  //  7:  "#   [<returnname> = ]<function>("
  231.  
  232.     for (i = 1; i <= 8; i++)
  233.     {   if (autodoc.var[i].name[0])
  234.         {   if (i >= 2)
  235.                 strcat(IOBuffer, ", ");
  236.             strcat(IOBuffer, autodoc.var[i].name);
  237.             size = strlen(autodoc.var[i].reg) - strlen(autodoc.var[i].name);
  238.             if (size > 0)
  239.                 for (j = 1; j <= size; j++)
  240.                     strcat(IOBuffer, " ");
  241.         } else break;
  242.     }
  243.     strcat(IOBuffer, ")\n");                //  7:  "#   [<returnname> = ]<function>([<arglist>])\n"
  244.  
  245.     // register line
  246.     strcat(IOBuffer, "*   ");               //  8:  "#   "
  247.     if (autodoc.var[0].reg[0] && autodoc.var[0].name[0])
  248.     {   strcat(IOBuffer, autodoc.var[0].reg);
  249.                                             //  8:  "#   [<returnreg>]"
  250.         size = strlen(autodoc.var[0].name) - strlen(autodoc.var[0].reg);
  251.         if (size > 0)
  252.             for (i = 1; i <= size; i++)
  253.                 strcat(IOBuffer, " ");      //  8:  "#   [<returnreg><spaces>]"
  254.         strcat(IOBuffer, "   ");            //  8:  "#   [<returnreg><spaces>   ]"
  255.     }
  256.     size = strlen(autodoc.function);
  257.     if (size >= 0) // this is no mistake
  258.         for (i = 0; i <= size; i++)
  259.             strcat(IOBuffer, " ");          //  8:  "#   [<returnreg><spaces>   ]<spaces>"
  260.  
  261.     for (i = 1; i <= 8; i++)
  262.     {   if (autodoc.var[i].reg[0])
  263.         {   if (i >= 2)
  264.                 strcat(IOBuffer, "  ");
  265.             strcat(IOBuffer, autodoc.var[i].reg);
  266.             size = strlen(autodoc.var[i].name) - strlen(autodoc.var[i].reg);
  267.             if (size > 0)
  268.                 for (j = 1; j <= size; j++)
  269.                     strcat(IOBuffer, " ");
  270.     }   }
  271.     strcat(IOBuffer, "\n");                 //  8:  "#   [<returnreg><spaces>   ]<spaces>[<reglist>]\n"
  272.  
  273.     strcat(IOBuffer, "*\n*   ");            //  9:  "#\n"
  274.                                             // 10:  "#   "
  275.     if (autodoc.var[0].type[0])
  276.     {   strcat(IOBuffer, autodoc.var[0].type);
  277.                                             // 10a: "#   <returntype>"
  278.         strcat(IOBuffer, " ");              // 10a: "#   <returntype> "
  279.     } else
  280.         strcat(IOBuffer, "void ");          // 10b: "#   void "
  281.     strcat(IOBuffer, autodoc.function);     // 10:  "#   <returntype>|void <function>"
  282.     strcat(IOBuffer, "(");                  // 10:  "#   <returntype>|void <function>("
  283.     if (!(autodoc.var[1].type))             // 10:  "#   <returntype>|void <function>([void]"
  284.         strcat(IOBuffer, "void");
  285.     else
  286.     {   for (i = 1; i <= 8; i++)
  287.         {   if (autodoc.var[i].type[0])
  288.             {   if (i >= 2)
  289.                     strcat(IOBuffer, ", ");
  290.                 strcat(IOBuffer, autodoc.var[i].type);
  291.             } else break;
  292.     }   }
  293.     strcat(IOBuffer, ");\n*\n*   FUNCTION\n*   ");
  294.                                             // 10:  "#   <returntype>|void <function>(void|<typelist>);\n"
  295.                                             // 11:  "#\n"
  296.                                             // 12:  "#   FUNCTION\n"
  297.                                             // 13:  "#   "
  298.     strcat(IOBuffer, StarBufferPtr[0]);     // 13:  "#   <buffer>"
  299.     strcat(IOBuffer, "\n*\n*   INPUTS\n");  // 13:  "#   <buffer>\n"
  300.                                             // 14:  "#\n"
  301.                                             // 15:  "#   INPUTS\n"
  302.  
  303.     bizarre();
  304.  
  305.     strcat(IOBuffer, "*\n*   RESULT\n*   ");
  306.                                             // 17:  "#\n"
  307.                                             // 18:  "#   RESULT\n"
  308.                                             // 19:  "#   "
  309.     if (!(autodoc.var[0].name[0]))
  310.         strcat(IOBuffer, "NONE");           // 19a: "#   NONE"
  311.     else
  312.     {   strcat(IOBuffer, autodoc.var[0].name);
  313.                                             // 19b: "#   <returnname>"
  314.         strcat(IOBuffer, " - ");            // 19b: "#   <returnname> - "
  315.         strcat(IOBuffer, StarBufferPtr[5]); // 19b: "#   <returnname> - <buffer>"
  316.     }
  317.  
  318.     strcat
  319.     (   IOBuffer,
  320.         "\n*\n"                             // 19a: "#   NONE\n"
  321.                                             // 19b: "#   <returnname> - <buffer>\n"
  322.                                             // 20:  "#\n"
  323.         "*   EXAMPLE\n*   "                 // 21:  "#   EXAMPLE\n"
  324.                                             // 22:  "#   "
  325.     );
  326.  
  327.     strcat(IOBuffer, StarBufferPtr[1]);     // 22:  "#   <buffer>"
  328.     strcat(IOBuffer, "\n*\n*   NOTES\n*   ");
  329.                                             // 22:  "#   <buffer>\n"
  330.                                             // 23:  "#\n"
  331.                                             // 24:  "#   NOTES\n"
  332.                                             // 25:  "#   "
  333.  
  334.     strcat(IOBuffer, StarBufferPtr[2]);     // 25:  "#   <buffer>"
  335.     strcat(IOBuffer, "\n*\n*   BUGS\n*   ");
  336.                                             // 25:  "#   <buffer>\n"
  337.                                             // 26:  "#\n"
  338.                                             // 27:  "#   BUGS\n"
  339.                                             // 28:  "#   "
  340.     strcat(IOBuffer, StarBufferPtr[3]);     // 28:  "#   <buffer>"
  341.     strcat(IOBuffer, "\n*\n*   SEE ALSO\n*   ");
  342.                                             // 28:  "#   <buffer>\n"
  343.                                             // 29:  "#\n"
  344.                                             // 30:  "#   SEE ALSO\n"
  345.                                             // 31:  "#   "
  346.  
  347.     strcat(IOBuffer, StarBufferPtr[4]);     // 31:  "#   <buffer>"
  348.  
  349.     strcat
  350.     (   IOBuffer,
  351.         "\n*\n"                             // 31:  "#   <buffer>\n"
  352.                                             // 32:  "#\n"
  353.         "*****************************************************************************\n"
  354.                                             // 33:  "<77 stars>\n"
  355.         "*\n*"                              // 34:  "#\n"
  356.                                             // 35:  "#"
  357.         "/\n"                               // 35:  "#/\n"
  358.     );
  359.  
  360.     for (i = 0; i <= MAXELEMENTS; i++)
  361.     {   if (StarBufferPtr[i])
  362.         {   FreeMem(StarBufferPtr[i], StarBufferSize[i]);
  363.             StarBufferPtr[i] = NULL;
  364.     }   }
  365.     // That was done as soon as possible, and also before anything that
  366.     // might fail.
  367.  
  368.     if (!autodoc.output[0] || saveas) // if we need a filename
  369.     {   if (saveasl("Save Autodoc"))
  370.         {   strcpy(autodoc.output, aslresult);
  371.             writeout(autodoc.output);
  372. }   }   }
  373.  
  374. MODULE void bizarre(void)
  375. {   // Service routine for autodoc2().
  376.  
  377.     ULONG i, j;
  378.     SWORD size, longest = 0, thislength; // must be signed
  379.     TEXT  line[VLONGFIELD + 1]; // better not make it too large, as it is
  380.                                 // a local (stack) variable.
  381.  
  382.     if (!inputs)
  383.     {   strcpy(line, "*   NONE\n");         // 16:  "#   NONE\n"
  384.     } else
  385.     {   for (i = 1; i <= inputs; i++)
  386.         {   thislength = strlen(autodoc.var[i].name);
  387.             if (thislength > longest)
  388.             {   longest = thislength;
  389.         }   }
  390.  
  391.         for (i = 1; i <= inputs; i++)
  392.         {   strcpy(line, "*   ");           // 16:  "#   "
  393.             strcat(line, autodoc.var[i].name);
  394.                                             // 16:  "#   <argname1>"
  395.             thislength = strlen(autodoc.var[i].name);
  396.             size = longest - thislength;
  397.             if (size > 0)
  398.             {   for (j = 1; j <= size; j++)
  399.                 {    strcat(line, " ");     // 16:  "#   <argname1><spaces>"
  400.             }   }
  401.             strcat(line, " - ");            // 16:  "#   <argname1><spaces> - "
  402.             strcat(line, StarBufferPtr[5 + i]); // 16:  "#   <argname1><spaces> - <buffer1>"
  403.             strcat(line, "\n");             // 16:  "#   <argname1><spaces> - <buffer1>\n"
  404.     }   }
  405.     strcat(IOBuffer, line);
  406. }
  407.  
  408. AGLOBAL void newautodoc(ABOOL display)
  409. {   ULONG i;
  410.  
  411.     autodoc.version = 0;
  412.     autodoc.loaded = FALSE;
  413.     strcpy(autodoc.library,     "");
  414.     strcpy(autodoc.function,    "");
  415.     strcpy(autodoc.description, "");
  416.     for (i = 0; i <= 8; i++)
  417.     {   autodoc.var[i].name[0] = 0;
  418.         autodoc.var[i].type[0] = 0;
  419.         autodoc.var[i].reg[0]  = 0;
  420.         autodoc.var[i].desc[0] = 0;
  421.     }
  422.     strcpy(autodoc.output,      "");
  423.  
  424.     if (display)
  425.         updateautodocgadgets();
  426. }
  427.  
  428. AGLOBAL void openautodoc(void)
  429. {   // as you can see, this is not yet implemented!
  430.  
  431.     updateautodocgadgets();
  432. }
  433.  
  434. AGLOBAL void autodoc_init(void)
  435. {   ULONG i;
  436.  
  437.     // array clearing
  438.     for (i = 0; i <= MAXELEMENTS; i++)
  439.     {   StarBufferPtr[i] = NULL;
  440.     }
  441.     newautodoc(FALSE);
  442. }
  443.  
  444. AGLOBAL void autodoc_loop(ULONG class, struct Gadget* addr, UWORD code)
  445. {   ULONG i;
  446.  
  447.     if (class == IDCMP_VANILLAKEY)
  448.     {   code = toupper(code);
  449.         if (code == ESCAPE)
  450.         {   page = 0;
  451.         } elif (code == 'R')
  452.         {   ActivateGadget(ST41_VarType[0], MainWindowPtr, NULL);
  453.         } elif (code >= '1' && code <= '8')
  454.         {   ActivateGadget(ST41_VarType[code - '1' + 1], MainWindowPtr, NULL);
  455.         } elif (code == 'T')
  456.         {   ActivateGadget(ST41_Library, MainWindowPtr, NULL);
  457.         } elif (code == 'N')
  458.         {   ActivateGadget(ST41_Function, MainWindowPtr, NULL);
  459.         } elif (code == 'D')
  460.         {   ActivateGadget(ST41_Desc, MainWindowPtr, NULL);
  461.         } elif (code == 'V')
  462.         {   ActivateGadget(IN41_Version, MainWindowPtr, NULL);
  463.         } elif (code == 'I')
  464.         {   countfields();
  465.             launcheditor(autodoc.output);
  466.  
  467.             /* StarBufferPtr[]s are as follows:
  468.             0: Function
  469.             1: Example
  470.             2: Notes
  471.             3: Bugs
  472.             4: See also
  473.             5: Return code
  474.          6-13: Inputs */
  475.  
  476.             for (i = 0; i <= 4; i++)
  477.             {   starify(i, autodoc.textfield[i]);
  478.             }
  479.             if (returncode)
  480.             {   starify(5, autodoc.var[0].desc);
  481.             }
  482.             if (inputs)
  483.             {   for (i = 1; i <= inputs; i++)
  484.                 {   starify(5 + i, autodoc.var[i].desc);
  485.     }   }   }   }
  486.     elif (class == IDCMP_GADGETUP)
  487.     {   if (addr == BU99_Right)
  488.         {   page = 0;
  489.         } elif (addr == BU99_TextEditor)
  490.         {   countfields();
  491.             launcheditor(autodoc.output);
  492.  
  493.             for (i = 0; i <= 4; i++)
  494.             {   starify(i, autodoc.textfield[i]);
  495.             }
  496.             if (returncode)
  497.             {   starify(5, autodoc.var[0].desc);
  498.             }
  499.             if (inputs)
  500.             {   for (i = 1; i <= inputs; i++)
  501.                 {   starify(5 + i, autodoc.var[i].desc);
  502. }   }   }   }   }
  503.  
  504. MODULE void updateautodocgadgets(void)
  505. {   ULONG i;
  506.  
  507.     GT_SetGadgetAttrs
  508.     (   ST41_Library,
  509.         MainWindowPtr,
  510.         NULL,
  511.         GTST_String, autodoc.library,
  512.         TAG_DONE
  513.     );
  514.     GT_SetGadgetAttrs
  515.     (   ST41_Function,
  516.         MainWindowPtr,
  517.         NULL,
  518.         GTST_String, autodoc.function,
  519.         TAG_DONE
  520.     );
  521.     GT_SetGadgetAttrs
  522.     (   ST41_Desc,
  523.         MainWindowPtr,
  524.         NULL,
  525.         GTST_String, autodoc.description,
  526.         TAG_DONE
  527.     );
  528.     GT_SetGadgetAttrs
  529.     (   IN41_Version,
  530.         MainWindowPtr,
  531.         NULL,
  532.         GTIN_Number, autodoc.version,
  533.         TAG_DONE
  534.     );
  535.     for (i = 0; i <= 8; i++)
  536.     {   GT_SetGadgetAttrs
  537.         (   ST41_VarType[i],
  538.             MainWindowPtr,
  539.             NULL,
  540.             GTST_String, autodoc.var[i].type,
  541.             TAG_DONE
  542.         );
  543.         GT_SetGadgetAttrs
  544.         (   ST41_VarName[i],
  545.             MainWindowPtr,
  546.             NULL,
  547.             GTST_String, autodoc.var[i].name,
  548.             TAG_DONE
  549.         );
  550.         GT_SetGadgetAttrs
  551.         (   ST41_VarReg[i],
  552.             MainWindowPtr,
  553.             NULL,
  554.             GTST_String, autodoc.var[i].reg,
  555.             TAG_DONE
  556.         );
  557. }   }
  558.  
  559. MODULE void readautodocgadgets(void)
  560. {   ULONG i;
  561.  
  562.     strcpy
  563.     (   autodoc.library,
  564.         ((struct StringInfo *) ST41_Library->SpecialInfo)->Buffer
  565.     );
  566.     strcpy
  567.     (   autodoc.function,
  568.         ((struct StringInfo *) ST41_Function->SpecialInfo)->Buffer
  569.     );
  570.     strcpy
  571.     (   autodoc.description,
  572.         ((struct StringInfo *) ST41_Desc->SpecialInfo)->Buffer
  573.     );
  574.     autodoc.version = ((struct StringInfo *) IN41_Version->SpecialInfo)->LongInt;
  575.     for (i = 0; i <= 8; i++)
  576.     {   strcpy
  577.         (   autodoc.var[i].type,
  578.             ((struct StringInfo *) ST41_VarType[i]->SpecialInfo)->Buffer
  579.         );
  580.         strcpy
  581.         (   autodoc.var[i].name,
  582.             ((struct StringInfo *) ST41_VarName[i]->SpecialInfo)->Buffer
  583.         );
  584.         strcpy
  585.         (   autodoc.var[i].reg,
  586.             ((struct StringInfo *) ST41_VarReg[i]->SpecialInfo)->Buffer
  587.         );
  588. }   }
  589.  
  590. MODULE void starify(ULONG theindex, STRPTR buffer)
  591. {   ULONG j, length, where;
  592.     ABOOL done;
  593.  
  594.     // first we count the number of LFs in the source buffer, and the
  595.     // length of the source buffer.
  596.     length = 0;
  597.     done = FALSE;
  598.     while (!done)
  599.     {   if (*(buffer + length) == LF)
  600.             StarBufferSize[theindex] += 4;
  601.         elif (*(buffer + length) == 0)
  602.             done = TRUE;
  603.         StarBufferSize[theindex]++;
  604.         length++;
  605.     }
  606.  
  607.     // now we allocate the buffer
  608.     if (!(StarBufferPtr[theindex] = AllocMem(StarBufferSize[theindex], MEMF_PUBLIC)))
  609.         rq("Out of memory!");
  610.  
  611.     // now we translate into new buffer
  612.     where = 0;
  613.     for (j = 0; j <= length; j++)
  614.     {   *(StarBufferPtr[theindex] + where) = *(buffer + j);
  615.         if (*(buffer + j) == LF)
  616.         {   *(StarBufferPtr[theindex] + where + 1) = '*';
  617.             *(StarBufferPtr[theindex] + where + 2) = ' ';
  618.             *(StarBufferPtr[theindex] + where + 3) = ' ';
  619.             *(StarBufferPtr[theindex] + where + 4) = ' ';
  620.             where += 4;
  621.         }
  622.         where++;
  623. }   }
  624.  
  625. MODULE void countfields(void)
  626. {   ULONG i;
  627.  
  628.     readautodocgadgets();
  629.  
  630.     if (autodoc.var[0].name[0])
  631.         returncode = 1; // non-boolean as it's used mathematically
  632.     else returncode = 0;
  633.  
  634.     inputs = 0;
  635.     for (i = 1; i <= 8; i++)
  636.     {   if (autodoc.var[i].name[0])
  637.             inputs++;
  638.         else break;
  639. }   }
  640.